﻿//public static class GlobalMembersGame_lifebar
//{

//	internal static LCUI_RGB_[] color_set = { new LCUI_RGB_(220, 0, 0), new LCUI_RGB_(255, 130, 0), new LCUI_RGB_(140, 205, 0), new LCUI_RGB_(10, 110, 210), new LCUI_RGB_(140, 135, 250) };

//	#define TYPE_NAME_AlternateDefinition1
//	#define TYPE_NAME

//	//* 计算生命条的数量 
//	internal static int LifeBar_CountBarNum(int cur_hp, int full_hp)
//	{
//		int n;
//		if(cur_hp <= full_hp)
//		{
//			return 1;
//		}
//		n = cur_hp / full_hp;
//		if(cur_hp % full_hp == 0)
//		{
//			return n;
//		}
//		return n+1;
//	}

//	//* 获取血条残影的颜色 
//	internal static void LifeBar_GetForeShadowColor(int n_lifebar, LCUI_RGB_ color)
//	{
//		if(n_lifebar > 0)
//		{
//			n_lifebar -= 1;
//		}
//		color.red = color_set[n_lifebar%5].red *4/5;
//		color.green = color_set[n_lifebar%5].green *4/5;
//		color.blue = color_set[n_lifebar%5].blue *4/5;
//	}

//	//* 获取背层血条残影的颜色 
//	internal static void LifeBar_GetBackShadowColor(int n_lifebar, LCUI_RGB_ color)
//	{
//		int n = 0;
//		if(n_lifebar > 0)
//		{
//			n_lifebar -= 1;
//		}
//		if(n_lifebar > 0)
//		{
//			n = n_lifebar%5 - 1;
//			if(n<0)
//			{
//				n = 4;
//			}
//		}
//		color.red = color_set[n].red *4/5;
//		color.green = color_set[n].green *4/5;
//		color.blue = color_set[n].blue *4/5;
//	}

//	internal static void LifeBar_UpdateShadow(IntPtr arg)
//	{
//		LifeBarData_ data;
//		double scale;
//		int cur_n;
//		int old_n;
//		string scale_str = new string(new char[10]);
//		LCUI_RGB_ fore_color = new LCUI_RGB_();
//		LCUI_RGB_ back_color = new LCUI_RGB_();

//		data = (LifeBarData_)Widget_GetPrivData((LCUI_Widget_)arg);
//		if(data.lifebar_shadow_state == DefineConstantsGame_lifebar.SHADOW_STATE_END_CLEAN)
//		{
//			return;
//		}

//		if(data.lifebar_shadow_state == DefineConstantsGame_lifebar.SHADOW_STATE_CLEAN)
//		{
//			// 如果还需要等几次 
//			if(data.n_erase_wait > 0)
//			{
//				--data.n_erase_wait;
//				return;
//			}
//			else
//			{
//				data.n_erase_wait = 0;
//			}
//		}

//		if(data.lifebar_shadow_state == DefineConstantsGame_lifebar.SHADOW_STATE_NEED_CLEAN)
//		{
//			data.lifebar_shadow_state = DefineConstantsGame_lifebar.SHADOW_STATE_CLEAN;
//		}
//		// 获取当前血条和残影血条的数量 
//		cur_n = LifeBar_CountBarNum(data.current_life_point, data.full_life_point);
//		old_n = LifeBar_CountBarNum(data.shadow_life_point, data.full_life_point);
//		if(old_n < cur_n)
//		{
//			return;
//		}
//		else if(old_n == cur_n) // 如果数量相同 
//		{
//			// 获取当前残影血条的前景色和背景色 
//			LifeBar_GetForeShadowColor(cur_n, fore_color);
//			LifeBar_GetBackShadowColor(cur_n, back_color);
//			// 计算在当前血槽上剩余的残影生命值 
//			scale = data.shadow_life_point % data.full_life_point;
//			if(scale == 0.0)
//			{
//				scale = 100.0;
//			}
//			else
//			{
//				scale = 100 * scale / data.full_life_point;
//			}
//			// 设置残影血条的颜色 
//			Widget_SetBackgroundColor(data.lifebar_shadow[2], fore_color);
//			Widget_SetBackgroundTransparent(data.lifebar_shadow[2], DefineConstantsGame_lifebar.FALSE);
//			scale_str = string.Format("{0:f2}%", scale);
//			// 设置残影血条的长度 
//			Widget_SetSize(data.lifebar_shadow[2], scale_str, "100%");
//			// 只显示最底层的血条残影 
//			Widget_Show(data.lifebar_shadow[2]);
//			// 隐藏上层的血条残影 
//			Widget_Hide(data.lifebar_shadow[1]);
//			Widget_Hide(data.lifebar_shadow[0]);
//		}
//		// 如果当前生命值刚好充满 cur_n 条血槽，并且残影血条量与当前血条量相差1条 
//		else if(data.current_life_point == cur_n data.full_life_point && old_n - cur_n == 1)
//		{
//			LifeBar_GetForeShadowColor(old_n, fore_color);
//			LifeBar_GetBackShadowColor(old_n, back_color);
//			scale = data.shadow_life_point % data.full_life_point;
//			if(scale == 0.0)
//			{
//				scale = 100.0;
//			}
//			else
//			{
//				scale = 100 * scale / data.full_life_point;
//			}
//			Widget_SetBackgroundColor(data.lifebar_shadow[2], fore_color);
//			Widget_SetBackgroundTransparent(data.lifebar_shadow[2], DefineConstantsGame_lifebar.FALSE);
//			scale_str = string.Format("{0:f2}%", scale);
//			Widget_SetSize(data.lifebar_shadow[2], scale_str, "100%");
//			Widget_Show(data.lifebar_shadow[2]);
//			Widget_Hide(data.lifebar_shadow[1]);
//			Widget_Hide(data.lifebar_shadow[0]);
//		}
//		else if(old_n - cur_n == 1)
//		{
//			LifeBar_GetForeShadowColor(old_n, fore_color);
//			LifeBar_GetForeShadowColor(cur_n, back_color);
//			scale = data.shadow_life_point % data.full_life_point;
//			if(scale == 0.0)
//			{
//				scale = 100.0;
//			}
//			else
//			{
//				scale = 100 * scale / data.full_life_point;
//			}
//			Widget_SetBackgroundColor(data.lifebar_shadow[1], fore_color);
//			Widget_SetBackgroundColor(data.lifebar_shadow[2], back_color);
//			Widget_SetBackgroundTransparent(data.lifebar_shadow[2], DefineConstantsGame_lifebar.FALSE);
//			Widget_SetBackgroundTransparent(data.lifebar_shadow[1], DefineConstantsGame_lifebar.FALSE);
//			scale_str = string.Format("{0:f2}%", scale);
//			Widget_SetSize(data.lifebar_shadow[1], scale_str, "100%");
//			Widget_SetSize(data.lifebar_shadow[2], "100%", "100%");
//			Widget_Show(data.lifebar_shadow[2]);
//			Widget_Show(data.lifebar_shadow[1]);
//			Widget_Hide(data.lifebar_shadow[0]);
//		}
//		else
//		{
//			LifeBar_GetForeShadowColor(old_n, fore_color);
//			LifeBar_GetBackShadowColor(old_n, back_color);
//			scale = data.shadow_life_point % data.full_life_point;
//			if(scale == 0.0)
//			{
//				scale = 100.0;
//			}
//			else
//			{
//				scale = 100 * scale / data.full_life_point;
//			}
//			Widget_SetBackgroundColor(data.lifebar_shadow[0], fore_color);
//			Widget_SetBackgroundColor(data.lifebar_shadow[1], back_color);
//			Widget_SetBackgroundTransparent(data.lifebar_shadow[2], DefineConstantsGame_lifebar.FALSE);
//			Widget_SetBackgroundTransparent(data.lifebar_shadow[1], DefineConstantsGame_lifebar.FALSE);
//			Widget_SetBackgroundTransparent(data.lifebar_shadow[0], DefineConstantsGame_lifebar.FALSE);
//			scale_str = string.Format("{0:f2}%", scale);
//			Widget_SetSize(data.lifebar_shadow[0], scale_str, "100%");
//			Widget_SetSize(data.lifebar_shadow[1], "100%", "100%");
//			Widget_SetSize(data.lifebar_shadow[2], "100%", "100%");
//			Widget_Show(data.lifebar_shadow[2]);
//			Widget_Show(data.lifebar_shadow[1]);
//			Widget_Show(data.lifebar_shadow[0]);
//		}
//		// 增加每次在残影血条上扣除的生命点，直到最大扣除量为止 
//		if(data.n_point_per_erase < data.full_life_point/20+1)
//		{
//			++data.n_point_per_erase;
//		}
//		data.shadow_life_point -= data.n_point_per_erase;
//		if(data.shadow_life_point <= data.current_life_point)
//		{
//			data.lifebar_shadow_state = DefineConstantsGame_lifebar.SHADOW_STATE_END_CLEAN;
//			Widget_Hide(data.lifebar_shadow[2]);
//			Widget_Hide(data.lifebar_shadow[1]);
//			Widget_Hide(data.lifebar_shadow[0]);
//		}
//	}

//	//* 定时更新闪光条 
//	internal static void LifeBar_UpdateFlashBar(IntPtr arg)
//	{
//		double scale;
//		int new_n;
//		int old_n;
//		string scale_str = new string(new char[10]);
//		byte alpha;
//		LifeBarData_ data;

//		data = (LifeBarData_)Widget_GetPrivData((LCUI_Widget_)arg);
//		if(data.need_show_flash)
//		{
//			data.need_show_flash = DefineConstantsGame_lifebar.FALSE;
//			if(data.old_life_point < data.current_life_point)
//			{
//				return;
//			}
//			new_n = LifeBar_CountBarNum(data.current_life_point, data.full_life_point);
//			old_n = LifeBar_CountBarNum(data.old_life_point, data.full_life_point);
//			// 如果扣血时减少了血条数 
//			if(old_n > new_n)
//			{
//				// 如果扣除的血量超过1条，并且之前刚好是满槽血 
//				if(old_n - new_n > 1 && data.old_life_point % data.full_life_point == 0)
//				{
//					scale = 100;
//				}
//				else
//				{
//					 // 计算闪光条的长度比例 
//					scale = data.old_life_point % data.full_life_point;
//					scale = 100 * scale / data.full_life_point;
//				}
//				scale_str = string.Format("{0:f2}%", scale);
//				Widget_SetSize(data.flashbar[0], scale_str, "100%");
//				Widget_SetAlpha(data.flashbar[0], 255);
//				// 在血条前面显示一个闪光，表示在之前那个血条里扣除的血量 
//				Widget_Show(data.flashbar[0]);
//				//如果当前生命值刚好充满 cur_n 条血槽，那就不需要显示背层残影血条 
//				if(data.current_life_point == new_n data.full_life_point)
//				{
//					Widget_Hide(data.flashbar[1]);
//				}
//				else
//				{
//					Widget_SetSize(data.flashbar[1], "100%", "100%");
//					Widget_SetAlpha(data.flashbar[1], 255);
//					// 在本血条后面显示一个闪光，表示在当前血条里扣除的血量 
//					Widget_Show(data.flashbar[1]);
//				}
//			}
//			else
//			{
//				// 否则，只在本血条后面显示一个闪光 
//				scale = data.old_life_point % data.full_life_point;
//				scale = 100 * scale / data.full_life_point;
//				scale_str = string.Format("{0:f2}%", scale);
//				Widget_SetSize(data.flashbar[1], scale_str, "100%");
//				Widget_SetAlpha(data.flashbar[1], 255);
//				Widget_Show(data.flashbar[1]);
//			}
//			return;
//		}
//		if(data.flashbar[0].visible)
//		{
//			alpha = Widget_GetAlpha(data.flashbar[0]);
//			if(alpha > 10)
//			{
//				alpha -= 10;
//				Widget_SetAlpha(data.flashbar[0], alpha);
//			}
//			else
//			{
//				alpha = 0;
//				Widget_Hide(data.flashbar[0]);
//			}
//		}
//		if(data.flashbar[1].visible)
//		{
//			alpha = Widget_GetAlpha(data.flashbar[1]);
//			if(alpha > 10)
//			{
//				alpha -= 10;
//				Widget_SetAlpha(data.flashbar[1], alpha);
//			}
//			else
//			{
//				alpha = 0;
//				Widget_Hide(data.flashbar[1]);
//			}
//		}
//	}

//	internal static void LifeBar_ExecInit(LCUI_Widget_ widget)
//	{
//		LifeBarData_ data;

//		data = (LifeBarData_)Widget_NewPrivData(widget, typeof(LifeBarData_));
//		data.current_life_point = 0;
//		data.full_life_point = 100;
//		data.max_life_point = 200;
//		data.old_life_point = 0;
//		data.need_show_flash = DefineConstantsGame_lifebar.FALSE;
//		data.lifebar_shadow_state = DefineConstantsGame_lifebar.SHADOW_STATE_END_CLEAN;
//		data.n_erase_wait = DefineConstantsGame_lifebar.SHADOW_N_WAIT;
//		data.lifebar = Widget_New(null);
//		data.flashbar[0] = Widget_New(null);
//		data.flashbar[1] = Widget_New(null);
//		data.lifebar_shadow[0] = Widget_New(null);
//		data.lifebar_shadow[1] = Widget_New(null);
//		data.lifebar_shadow[2] = Widget_New(null);
//		// 加入至容器 
//		Widget_Container_Add(widget, data.lifebar);
//		Widget_Container_Add(widget, data.flashbar[0]);
//		Widget_Container_Add(widget, data.flashbar[1]);
//		Widget_Container_Add(widget, data.lifebar_shadow[0]);
//		Widget_Container_Add(widget, data.lifebar_shadow[1]);
//		Widget_Container_Add(widget, data.lifebar_shadow[2]);
//		// 调整堆叠顺序 
//		Widget_SetZIndex(data.flashbar[0], 5);
//		Widget_SetZIndex(data.lifebar_shadow[0], 4);
//		Widget_SetZIndex(data.lifebar_shadow[1], 3);
//		Widget_SetZIndex(data.lifebar, 2);
//		Widget_SetZIndex(data.flashbar[1], 1);
//		Widget_SetZIndex(data.lifebar_shadow[2], 0);

//		Widget_SetBorder(widget, Border(2,BORDER_STYLE_SOLID,RGB(150,150,150)));
//		Widget_SetPadding(widget, Padding(2,2,2,2));
//		Widget_SetAlign(data.lifebar, ALIGN_TYPE_.ALIGN_MIDDLE_LEFT, Pos(0,0));
//		Widget_SetAlign(data.lifebar_shadow[0], ALIGN_TYPE_.ALIGN_MIDDLE_LEFT, Pos(0,0));
//		Widget_SetAlign(data.lifebar_shadow[1], ALIGN_TYPE_.ALIGN_MIDDLE_LEFT, Pos(0,0));
//		Widget_SetAlign(data.lifebar_shadow[2], ALIGN_TYPE_.ALIGN_MIDDLE_LEFT, Pos(0,0));
//		Widget_SetAlign(data.flashbar[0], ALIGN_TYPE_.ALIGN_MIDDLE_LEFT, Pos(0,0));
//		Widget_SetAlign(data.flashbar[1], ALIGN_TYPE_.ALIGN_MIDDLE_LEFT, Pos(0,0));
//		Widget_SetBackgroundTransparent(data.lifebar, DefineConstantsGame_lifebar.FALSE);
//		Widget_SetBackgroundTransparent(widget, DefineConstantsGame_lifebar.FALSE);
//		Widget_SetBackgroundTransparent(data.flashbar[0], DefineConstantsGame_lifebar.FALSE);
//		Widget_SetBackgroundTransparent(data.flashbar[1], DefineConstantsGame_lifebar.FALSE);
//		Widget_SetBackgroundColor(data.flashbar[0], RGB(255,255,255));
//		Widget_SetBackgroundColor(data.flashbar[1], RGB(255,255,255));
//		Widget_SetBackgroundColor(data.lifebar, color_set[0]);
//		Widget_SetBackgroundColor(widget, RGB(100,100,100));
//		Widget_Show(data.lifebar);
//		// 创建一个定时器，实现闪光条的淡出效果 
//		data.timer_flashbar = LCUITimer_Set(20, LifeBar_UpdateFlashBar, (IntPtr)widget, DefineConstantsGame_lifebar.TRUE);
//		data.timer_lifebar_shadow = LCUITimer_Set(20, LifeBar_UpdateShadow, (IntPtr)widget, DefineConstantsGame_lifebar.TRUE);
//	}

//	internal static void LifeBar_ExecDestroy(LCUI_Widget_ widget)
//	{
//		LifeBarData_ p_data;

//		p_data = (LifeBarData_)Widget_GetPrivData(widget);
//		LCUITimer_Free(p_data.timer_flashbar);
//		LCUITimer_Free(p_data.timer_lifebar_shadow);
//	}

//	internal static void LifeBar_ExecUpdate(LCUI_Widget_ widget)
//	{
//		double scale;
//		string scale_str = new string(new char[15]);
//		LifeBarData_ data;

//		data = (LifeBarData_)Widget_GetPrivData(widget);
//		scale = data.current_life_point % data.full_life_point;
//		scale = scale * 100 / data.full_life_point;
//		scale_str = string.Format("{0:f2}%", scale);
//		Widget_SetSize(data.lifebar, scale_str, "100%");
//	}

//	//* 创建一个生命条（血条） 
//	public static LCUI_Widget_ LifeBar_New()
//	{
//		return Widget_New(DefineConstantsGame_lifebar.TYPE_NAME);
//	}

//	//* 为生命条设置一条生命槽能够容纳的生命值 
//	public static void LifeBar_SetFullHP(LCUI_Widget_ widget, int hp)
//	{
//		LifeBarData_ data;
//		data = (LifeBarData_)Widget_GetPrivData(widget);
//		data.full_life_point = hp;
//		Widget_Update(widget);
//	}

//	//* 为生命条设置当前生命值 
//	public static void LifeBar_SetHP(LCUI_Widget_ widget, int hp)
//	{
//		LifeBarData_ data;
//		int n_lifebar;
//		int n;
//		LCUI_RGB_ back_color = new LCUI_RGB_();
//		LCUI_RGB_ fore_color = new LCUI_RGB_();
//		LCUI_Border border = new LCUI_Border();

//		data = (LifeBarData_)Widget_GetPrivData(widget);
//		// 生命值不得低于0 
//		if(hp < 0)
//		{
//			hp = 0;
//		}
//		// 根据当前生命值，计算血条数量 
//		n_lifebar = data.current_life_point / data.full_life_point;
//		// 如果当前血条数不等于新血条数 
//		if(n_lifebar != (hp / data.full_life_point))
//		{
//			n_lifebar = hp / data.full_life_point;
//			if(hp < data.full_life_point)
//			{
//				// 生命值满不了一条生命槽，改用另一种背景色 
//				back_color.red = 100;
//				back_color.green = 100;
//				back_color.blue = 100;
//				fore_color = color_set[0];
//			}
//			else
//			{
//				// 根据血条数，得出需要使用的颜色 
//				n = n_lifebar%5 - 1;
//				// 颜色序号小于0，则使用第4个颜色 
//				if(n<0)
//				{
//					n = 4;
//				}
//				back_color = color_set[n];
//				fore_color = color_set[n_lifebar%5];
//			}
//			// 上、下、左边框宽度为0 
//			border.top_width = 0;
//			border.bottom_width = 0;
//			border.left_width = 0;
//			// 设置右边框的宽度 
//			border.right_width = 1;
//			border.right_style = BORDER_STYLE_SOLID;
//			// 设置右边框颜色 
//			border.right_color.red = fore_color.red;
//			border.right_color.green = fore_color.green;
//			border.right_color.blue = fore_color.blue;
//			border.right_color.red += (255-fore_color.red)/2;
//			border.right_color.green += (255-fore_color.green)/2;
//			border.right_color.blue += (255-fore_color.blue)/2;
//			// 不使用圆角 
//			border.bottom_left_radius = 0;
//			border.bottom_right_radius = 0;
//			border.top_left_radius = 0;
//			border.top_right_radius = 0;
//			// 设置生命槽里的血条的边框 
//			Widget_SetBorder(data.lifebar, border);
//			// 设置生命槽里的血条的背景颜色 
//			Widget_SetBackgroundColor(data.lifebar, fore_color);
//			// 生命槽的背景颜色 
//			Widget_SetBackgroundColor(widget, back_color);
//			// 生命槽需要重绘 
//			Widget_Draw(widget);
//		}
//		data.old_life_point = data.current_life_point;
//		data.current_life_point = hp;
//		// 如果是扣血，那就记录扣血前的血量，并标记需要显示闪光 
//		if(hp < data.old_life_point)
//		{
//			data.need_show_flash = DefineConstantsGame_lifebar.TRUE;
//			// 如果不需要抹去血条残影，则说明可以显示血条残影 
//			if(data.lifebar_shadow_state == DefineConstantsGame_lifebar.SHADOW_STATE_END_CLEAN)
//			{
//				// 记录本次扣血前的血量，并标记需要抹去血条残影 
//				data.shadow_life_point = data.old_life_point;
//				data.n_point_per_erase = 1;
//				data.n_erase_wait = DefineConstantsGame_lifebar.SHADOW_N_WAIT;
//				data.lifebar_shadow_state = DefineConstantsGame_lifebar.SHADOW_STATE_NEED_CLEAN;
//			}
//		}
//		// 血条的长度需要更新 
//		Widget_Update(widget);
//	}

//	//* 为生命条设置最大生命值 
//	public static void LifeBar_SetMaxHP(LCUI_Widget_ widget, int hp)
//	{
//		LifeBarData_ data;
//		data = (LifeBarData_)Widget_GetPrivData(widget);
//		if(hp <= 0)
//		{
//			return;
//		}
//		data.max_life_point = hp;
//		// 更新当前血条的数据 
//		LifeBar_SetHP(widget, data.current_life_point);
//	}

//	//* 获取生命条的数量 
//	public static int LifeBar_GetBarNum(LCUI_Widget_ widget)
//	{
//		LifeBarData_ data;

//		data = (LifeBarData_)Widget_GetPrivData(widget);
//		return LifeBar_CountBarNum(data.current_life_point, data.full_life_point);
//	}

//	//* 注册生命条部件 
//	public static void LifeBar_Regiser()
//	{
//		WidgetType_Add(DefineConstantsGame_lifebar.TYPE_NAME);
//		WidgetFunc_Add(DefineConstantsGame_lifebar.TYPE_NAME, LifeBar_ExecInit, FuncType_.FUNC_TYPE_INIT);
//		WidgetFunc_Add(DefineConstantsGame_lifebar.TYPE_NAME, LifeBar_ExecDestroy, FuncType_.FUNC_TYPE_DESTROY);
//		WidgetFunc_Add(DefineConstantsGame_lifebar.TYPE_NAME, LifeBar_ExecUpdate, FuncType_.FUNC_TYPE_UPDATE);
//	}
//}
//// ****************************************************************************
//// * Punch And Kick -- a simple 2D Fighting Game.
//// *
//// * Copyright (C) 2013 by
//// * Liu Chao
//// *
//// * This file is part of the Punch And Kick project, and may only be used,
//// * modified, and distributed under the terms of the GPLv2.
//// *
//// * (GPLv2 is abbreviation of GNU General Public License Version 2)
//// *
//// * By continuing to use, modify, or distribute this file you indicate that you
//// * have read the license and understand and accept it fully.
//// *
//// * The Punch And Kick project is distributed in the hope that it will be
//// * useful, but WITHOUT ANY WARRANTY; without even the implied warranty of 
//// * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GPL v2 for
//// * more details.
//// *
//// * You should have received a copy of the GPLv2 along with this file. It is
//// * usually in the LICENSE.TXT file, If not, see <http://www.gnu.org/licenses/>.
//// * **************************************************************************

//// ****************************************************************************
//// * Punch And Kick -- 一个普通的2D格斗游戏
//// *
//// * 版权所有 (C) 2013 归属于
//// * 刘超
//// *
//// * 这个文件是 Punch And Kick 项目的一部分，并且只可以根据GPLv2许可协议来使用、
//// * 更改和发布。
//// *
//// * (GPLv2 是 GNU通用公共许可证第二版 的英文缩写)
//// *
//// * 继续使用、修改或发布本文件，表明您已经阅读并完全理解和接受这个许可协议。
//// *
//// * Punch And Kick 项目是基于技术交流目的而加以散布的，但不负任何担保责任，例
//// * 如：稳定性、可玩性、趣味性等的担保，甚至没有适销性或特定用途的隐含担保，详
//// * 情请参照GPLv2许可协议。
//// *
//// * 您应已收到附随于本文件的GPLv2许可协议的副本，它通常在LICENSE.TXT文件中，如果
//// * 没有，请查看：<http://www.gnu.org/licenses/>.
//// * **************************************************************************

//// LifeBar：生命条，血条


//#define SHADOW_N_WAIT

//#define SHADOW_STATE_CLEAN
//#define SHADOW_STATE_END_CLEAN
//#define SHADOW_STATE_NEED_CLEAN

//public class LifeBarData_
//{
//	public GlobalMembersGame_lifebar.int current_life_point; //*< 当前生命点 
//	public GlobalMembersGame_lifebar.int old_life_point; //*< 扣血前的生命点 
//	public GlobalMembersGame_lifebar.int full_life_point; //*< 满血条的生命点数 
//	public GlobalMembersGame_lifebar.int max_life_point; //*< 能够拥有的最大生命点 
//	public GlobalMembersGame_lifebar.int shadow_life_point; //*< 血条残影表示的血量 
//	public GlobalMembersGame_lifebar.int timer_flashbar; //*< 闪光条的定时器 
//	public GlobalMembersGame_lifebar.int timer_lifebar_shadow; //*< 生命条残影的定时器 
//	public GlobalMembersGame_lifebar.int n_erase_wait; //*< 抹去生命条残影前需要等待的次数 
//	public GlobalMembersGame_lifebar.int n_point_per_erase; //*< 每次抹去时扣除的残影上的生命点数 
//	public LCUI_BOOL need_show_flash = new LCUI_BOOL(); //*< 指示是否需要显示闪光 
//	public GlobalMembersGame_lifebar.int lifebar_shadow_state; //*< 生命条残影的状态 
//	public GlobalMembersGame_lifebar.LCUI_Widget_ lifebar; //*< 当前生命条 
//	public GlobalMembersGame_lifebar.LCUI_Widget_[] flashbar = new GlobalMembersGame_lifebar.LCUI_Widget_[2]; //*< 扣血时显示的闪光条 
//	public GlobalMembersGame_lifebar.LCUI_Widget_[] lifebar_shadow = new GlobalMembersGame_lifebar.LCUI_Widget_[3]; //*< 生命条残影 
//}